//	COPYRIGHT (C) 1981 BY BOARD OF TRUSTEES,
//	LELAND STANFORD JUNIOR UNIVERSITY

/* 


MODIFICATIONS JAN 80, BELIEF/DISBELIEF RATINGS MAY NOW BE ASSOCIATED WITH CASES.

*/
MANIFEST $( CGPNDSYM = #174; ANYBSYM = #174 $);
STATIC $( FVSINCLUDED = TRUE $);

LET STRCTELIST() BE
 $( STATIC $( NDIX = NIL; NBR = NIL; NBRS = NIL; NISB = NIL;
              ARTYPE = NIL; HYBTYPE = NIL; COLOURS = NIL; CTE = NIL; HMIN = NIL; HMAX = NIL;
              CGPND = NIL; V = NIL $)
 /* CARHART's function for reading a CASE in and representing it in
 much the same LISP-LIST format as used for EDITSTRUC structures.
 The lists like CTELIST are predefined and have appropriate atom types
 etc preset.
 */

 MAPC(IBLIST,UNCONS);
 UNLIST(IBLIST);
 IBLIST:=@NULL;
 MAPC(ANYBONDS,UNCONS);
 UNLIST(ANYBONDS);
 ANYBONDS:=@NULL;
 NDIX:=0;
 NBR:=[INCH()+80] REM 128;
 WHILE NBR NE 127 DO
  $(
  NDIX+:=1;
  NISB:=0;
  TEST NBR=CGPNDSYM THEN
   $(
   ARTYPE:=[INCH()+80] REM 128;
   HYBTYPE:=[INCH()+80] REM 128;
   COLOURS:=[INCH()+80] REM 128
   COLOURS:=COLOURS << 6
   COLOURS:=COLOURS+ ([INCH()+80] REM 128)
   HMIN:=[INCH()+80] REM 128;
   HMAX:=[INCH()+80] REM 128;
   NBR:=[INCH()+80] REM 128;
   CGPND:=TRUE
   $)
  OR $( CGPND:=FALSE; ARTYPE:=3 $);
  NBRS:=@NULL;
  UNTIL NBR=0 DO
   $(
   TEST NBR=NDIX THEN NISB+:=1
   OR
    TEST NBR=125 THEN UNLESS CGPND DO ARTYPE:=2
    OR
     TEST NBR=ANYBSYM THEN
      IF NDIX>CAR(NBRS) DO ANYBONDS:=CONS(CONS(NDIX,CAR(NBRS)),ANYBONDS)
     OR NBRS:=CONS(NBR,NBRS);
   NBR:=[INCH()+80] REM 128
   $);
  CTE:=ASSOC(NDIX,CTELIST);
  IF FVSINCLUDED DO
   $(
   V:=VALENCE(CAR(FETCH(CTE.ATS,CTE)));
   IF V>0 DO NBRS:=NCONC(NBRS,LISTOF(V-LENGTH(NBRS)-HMIN,0))
   $);
  UNLIST(FETCH(CTE.NBRS,CTE));
  REPLACE(CTE.NBRS,CTE,NBRS);
  REPLACE(CTE.COLOURS,CTE,COLOURS)
  REPLACE(CTE.MARKS,CTE,
        (HYBTYPE=15 ->0,(HYBTYPE << 5))+
	 (ARTYPE=3 -> 0,(ARTYPE=2 -> ARMARK,NONARMARK)));

  IF CGPND DO REPLND2(FETCH(CTE.HR,CTE),HMIN,HMAX);
  IF NISB>0 DO IBLIST:=CONS(CONS(NDIX,[NISB>>1]),IBLIST);
  NBR:=[INCH()+80] REM 128;
  $)
 $);



// N.B. THIS CODE DOES NOT REFLECT NEW "HYBRIDISATION" TAG ON ATOMS.
// 
// 
// let WRTCTECASE(STNUM) be $(WRTCAS
// /* Have a case, represented in the CTELIST format, which we now need to
// have written out in the CASE format!
// */
// static $( NDIX = NIL; NBR = NIL; NBRS = NIL; NISB = NIL; ARTYPE = NIL; HYBTYPE = NIL;
//           CTE = NIL; HRANGE = NIL; HMIN = NIL; HMAX = NIL; NNODES = NIL
// 	  TMP = NIL; TEMP = NIL; IBNUM = NIL
// 	$)
// 
// 
// OUTCH([126+48] REM 128); /* Presumably outputs a dot to mark start of case. */
// OUTNOS(STNUM); /* And that outputs the structure number. */
// OUTNOS(BELIEF);
// OUTNOS(DISBELIEF);
// 
// 
// NNODES:=LENGTH(CTELIST);
// NDIX:=0;
// 
// while NDIX<NNODES do $(nxtnd
// 	NDIX+:=1
// 	CTE:=ASSOC(NDIX,CTELIST)
// 	if CTE=@NULL then loop
// 	NBRS:=FETCH(CTE.NBRS,CTE)
// 	HRANGE:=FETCH(CTE.HR,CTE)
// 	HMIN:=CAR(HRANGE)
// 	HMAX:=CDR(HRANGE)
// 
// 	/* The default ARTYPE seems to be EITHER (code 3) */
// 
// 	ARTYPE:=(ARSPECP(CTE)->
// 			((ARP(CTE) & NONARP(CTE))->3,
// 			   (ARP(CTE)->2,1)),
// 			3);
// 	OUTCH([CGPNDSYM + 48] REM 128); /* Character marking start of a node definition. */
// 	OUTCH([ARTYPE + 48] REM 128);
// 	OUTCH([HMIN + 48] REM 128);
// 	OUTCH([HMAX + 48] REM 128);
// 
//         /* Determine if have internal bonds, (not certain how they would
// 	get there but seem to have to make such allowances).
// 	*/
// 	IBNUM:=ASSOC(NDIX,IBLIST)
// 	IBNUM:=(IBNUM=@NULL->0,CDR(IBNUM))
// 
// 	/* Have to output the neighbours now, 
// 	several problems due mainly to uncertainty re file-formats etc
// 	etc
// 	certainly have to work data on ANYBONDS back into the
// 	neighbours table
// 	feel that should reorder NBRS for other parts of program
// 	may assume an ordered list and this will have been reversed
// 	on reading in via STRCTELIST.
// 	*/
// 	TEMP:=@NULL
//         TMP:=NBRS
// 	until TMP=@NULL do $( NBR:=CAR(TMP); TMP:=CDR(TMP); TEMP:=CONS(NBR,TEMP) $)
// 	TMP:=TEMP
// 	until TMP = @NULL do $(
// 		NBR:=CAR(TMP); TMP:=CDR(TMP)
// 		
// 		/* The NBRs list is filled out with zeros for FVs. */
// 
// 		if NBR=0 then loop;
// 
// 
// 		/* See if should put any self bonds in here. */
// 		if ((NBR>NDIX) & (IBNUM>0)) do $(ibs
// 			for i=1 to IBNUM do OUTCH([48+NDIX] REM 128)
// 			IBNUM:=0
// 			$)ibs
// 
// 		test ANYBENTRY(NDIX,NBR)=@NULL then OUTCH([48+NBR] REM 128)
// 		or $( OUTCH([48+NBR] REM 128); OUTCH([ANYBSYM+48] REM 128) $)
// 		$)
// 	OUTCH(48) /* Thats the terminating zero I suppose */
// 	UNLIST(TEMP)
// 	$)nxtnd
// 
// OUTCH(47); /* Some special end marker character. */
// 
// $)WRTCAS
// 

let REPORT(STR,DATA,LENGTH,OFFSET) be $(RPRT
    static $( COUNT = NIL; FIRST1 = NIL; LIM = NIL; FIRST = NIL; LAST = NIL $)
    FIRST:=LENGTH; LAST:=-1;
    for N=0 to LENGTH do
       if DATA!N GR 0 then $( LAST:=N; FIRST:=(FIRST>N->N,FIRST) $)
    FIRST1:=FIRST;
    until FIRST1>LAST do $(
	COUNT:=0
        for N=FIRST1 to LAST do 
		if DATA!N>0 then $( LIM:=N; COUNT+:=1;
		   if COUNT=10 then break
		   $)
	OUTS(STR)
	for N=FIRST1 to LIM do if DATA!N>0 then OUTNON(N+OFFSET,4)
	NEWLINE(1)
	OUTS("Frequency of occurrence        : ")
	for N=FIRST1 to LIM do if DATA!N>0 then OUTNON(DATA!N,4)
	NEWLINE(1)
	FIRST1:=LIM+1
	$)

    NEWLINE(2)
    $)RPRT



let SHOWSCORES() be $(Scrs
 /* Run through all defined structures listing off current scores
 */


  static $( OIN = NIL; STNUM = NIL; STRUCPOS = NIL; TOPPOS = NIL;
	   MINSCORE = NIL; MAXSCORE = NIL; ALLSCORES = NIL;
           NNODES = NIL $)




  OIN:=INPUT
  INPUT:=FINDFILE("DSK",STRFILENAME(),CGEXT)


/* skip over various bits of leading data, number atoms etc. */
  NNODES:=INNO(); 
  INNO();
  for I=1 to NNODES do $(
    INS()
    $)
 

  ALLSCORES:=NEWVEC(CFMAX+CFMAX)
  for N=0 to (CFMAX+CFMAX) do ALLSCORES!N:=0;
  MINSCORE:=CFMAX
  MAXSCORE:=-CFMAX
  OUTS("CASE index numbers and scores:*C*L")
  STNUM:=0
  STRUCPOS:=0
  TOPPOS:=CAR(STRUCSTATUS)
  while STRUCPOS<TOPPOS do $(
    unless ([INCH()+80] REM 128) =126 do break
    STRUCPOS+:=1
    STNUM:=INNO()
    BELIEF:=INNO();DISBELIEF:=INNO(); SCORE:=BELIEF-DISBELIEF
    ALLSCORES!(CFMAX+SCORE)+:=1
    MINSCORE:=(SCORE<MINSCORE->SCORE,MINSCORE)
    MAXSCORE:=(SCORE>MAXSCORE->SCORE,MAXSCORE)
    OUTNON(STNUM,6); SPACES(2); OUTNON(SCORE,4); SPACES(1);
    /* SKIP OVER REST OF DATA ON STRUCTURE, (? SOME MAGIC CHARACTER BEING TESTED,
	STANDARD CARHART CODE).
    */
    SKIPSEG((127+48) REM 128);
    if (STRUCPOS REM 4)=0 then NEWLINE(1)
    $)

  ENDREAD(INPUT)
  INPUT:=OIN
  NEWLINE(1)
  if (MAXSCORE>-CFMAX) | (MINSCORE<CFMAX) then $(scores
	OUTS("*C*LScores associated with the different cases ranged from ");
	OUTNOS(MINSCORE); OUTS("to "); OUTNOL(MAXSCORE)
  $)scores
  REPORT("Score                          : ",ALLSCORES,CFMAX+CFMAX,-CFMAX)
  FREEVEC(ALLSCORES)

$)Scrs



LET MAPSTRUCFILE(POSMINMAXS,LITMINMAXS,SCORERANGE,
	EATSTRUCFN) = VALOF
 $( STATIC $( STNUM = NIL; STRUCPOS = NIL; TOPPOS = NIL; APPROPNO = NIL
              ABOVEALLMAX = NIL; INSOMERANGE = NIL $);

 LET MINMAXTEST(MINMAX) = VALOF
  $(
  TEST APPROPNO LE CDR(MINMAX) THEN ABOVEALLMAX:=FALSE OR RESULTIS FALSE;
  RESULTIS APPROPNO GE CAR(MINMAX)
  $);
 
 LET SCOREMINMAXTEST(MINMAX) = VALOF
  $(
   static $( LOWLIM = NIL; HIGHLIM = NIL $);
   LOWLIM:=CAR(MINMAX); HIGHLIM:=CDR(MINMAX);
   /* Because can't store -ve numbers in lists have offset the values given. */
   LOWLIM-:=CFMAX; HIGHLIM-:=CFMAX;
  UNLESS SCORE LE HIGHLIM DO  RESULTIS FALSE;
  RESULTIS SCORE GE LOWLIM
  $);

 STNUM:=0;
 STRUCPOS:=0;
 TOPPOS:=CAR(STRUCSTATUS);
 WHILE STRUCPOS<TOPPOS DO
  $(
  UNLESS [[INCH()+80] REM 128]=126 DO RESULTIS -1;
  STRUCPOS:=STRUCPOS+1;
  STNUM:=INNO();
  BELIEF:=INNO();DISBELIEF:=INNO();SCORE:=BELIEF-DISBELIEF;
  INCH();
  ABOVEALLMAX:=TRUE;
  /* If using scores can't rely on ABOVEALLMAX getting set correctly. */
  if SCORERANGE NE @NULL do ABOVEALLMAX:=FALSE;

  APPROPNO:=STRUCPOS;
  TEST SOME(POSMINMAXS,MINMAXTEST) NE @NULL THEN INSOMERANGE:=TRUE
  OR
   $(
   APPROPNO:=STNUM;
   TEST SOME(LITMINMAXS,MINMAXTEST) NE @NULL THEN INSOMERANGE:=TRUE
   OR $(
     INSOMERANGE:=SOME(SCORERANGE,SCOREMINMAXTEST) NE @NULL
     $)
   $);
  UNLESS EATSTRUCFN(STNUM,STRUCPOS,(INSOMERANGE -> 0,(ABOVEALLMAX -> 1,-1)))
   DO RESULTIS STRUCPOS
  $);
 RESULTIS TOPPOS
 $);




LET STRUCDROPPER(POSMINMAXS,LITMINMAXS,SCORERANGE) = VALOF
 $( STATIC $( NFORG = NIL; NSTRUCS = NIL; OOUT = NIL; OIN = NIL;
              OUTFILE = NIL; NNODES = NIL; MINSTNUM = NIL; MAXSTNUM = NIL $);

 LET EACHSTRUCFN(STNUM,STRUCPOS,RANGELOC) = VALOF
  $(
  /* If RANGELOC=0 then this structure already identified as one
 that should be omitted.
 */
  
  TEST RANGELOC=0 THEN
   $(DROP
   OUTPUT:=OOUT;
   NFORG:=NFORG+1;
   TEST NFORG>50 THEN
    IF NFORG=51 DO
     OUTS("*C*L...(I WON'T BOTHER LISTING THE REST OF THEM)...*C*L")
   OR
    $(
    IF NFORG=1 DO OUTS("FORGETTING ");
    OUTCH('#');
    OUTNOS(STNUM)
    $);
   OUTPUT:=OUTFILE;
   SKIPSEG([127+48] REM 128);
   NSTRUCS:=NSTRUCS-1
   $)DROP
  OR
   $(COPY
   /* This structure (CASE) has not been eliminated by the
   index number restrictions etc included in RANGELOC.
   we can just copy
   it from the input file to the output file without ever reading
   it in and building up its representation as a structure.
   */
   OUTCH([126+48] REM 128);
   OUTNOS(STNUM);
   OUTNOS(BELIEF); OUTNOS(DISBELIEF)
   COPYSEG([127+48] REM 128,TRUE);
   IF MINSTNUM=0 DO MINSTNUM:=STNUM;
   MAXSTNUM:=STNUM
   $)COPY
  RESULTIS TRUE
  $);

 MINSTNUM:=0;
 NFORG:=0;
 NSTRUCS:=CAR(STRUCSTATUS);
 OOUT:=OUTPUT;
 OIN:=INPUT;
 OUTFILE:=CREATEFILE("DSK",SC1FILENAME(),CGEXT);
 OUTPUT:=OUTFILE;
 INPUT:=FINDFILE("DSK",STRFILENAME(),CGEXT);
 NNODES:=INNO();
 OUTNOS(NNODES);
 OUTNOS(INNO());


 WHILE NNODES>0 DO $( NNODES:=NNODES-1; OUTS(INS()); SPACES(1) $);


 IF MAPSTRUCFILE(POSMINMAXS,LITMINMAXS,SCORERANGE,EACHSTRUCFN)<0 DO
  OUTCH([127+48] REM 128);
 COPYTOEND();
 ENDREAD(INPUT);
 ENDWRITE(OUTPUT);


 OUTPUT:=OOUT;
 INPUT:=OIN;
 IF NFORG=0 DO
  $(
  DELETEFILE(SC1FILENAME(),CGEXT);
  OUTS("EMPTY CASE RANGE*C*L");
  RESULTIS @NULL
  $);
 NEWLINE(1);
 IF NSTRUCS=0 DO
  OUTS("ALL CASES FORGOTTEN: I'LL NEED TO FORGET THEIR HISTORY, TOO*C*L");
 RESULTIS LIST(NSTRUCS,MINSTNUM,MAXSTNUM)
 $);






LET DROPPER(DEFLIST,POSMINMAXS,LITMINMAXS,SCORERANGE) = VALOF
 $( STATIC $( OOUT = NIL; OIN = NIL; OUTFILE = NIL; DROPPEDENTRY = NIL;
              NEWSS = NIL; DEFSTRNUM = NIL; DEFS = NIL $);



 TEST ([POSMINMAXS=@NULL] BITAND 
	[LITMINMAXS=@NULL] BITAND 
	(SCORERANGE=@NULL)) THEN NEWSS:=@NULL
 OR NEWSS:=STRUCDROPPER(POSMINMAXS,LITMINMAXS,SCORERANGE);


 UNLESS [NEWSS NE @NULL] BITOR [DEFLIST NE @NULL] DO RESULTIS FALSE;
 OOUT:=OUTPUT;
 OIN:=INPUT;
 OUTFILE:=CREATEFILE("DSK",SC2FILENAME(),CGEXT);
 OUTPUT:=OUTFILE;
 INPUT:=FINDFILE("DSK",TOPFILENAME(),CGEXT);
 SWAPLITEMS();
 IF NEWSS NE @NULL DO
  $(
  COPYSEGSTO(CHUNKSEP,SSHEADSTR,TRUE);
  LINEIN("");
  OUTNOL(CAR(NEWSS));
  LINEIN("");
  OUTNOS(CAR(CDR(NEWSS)));
  OUTNOL(CAR(CDR(CDR(NEWSS))));
  IF CAR(NEWSS)=0 DO
   $(
   COPYSEGSTO(CHUNKSEP,HIHEADSTR);
   LINEIN("") REPEATUNTIL NEXTIS(EOLTYPE);
   NEWLINE(1)
   $)
  $);
 COPYSEGSTO(CHUNKSEP,ESHEADSTR,TRUE);
 IF DEFLIST NE @NULL DO
  $(
  OUTPUT:=OOUT;
  OUTS("FORGETTING ");
  OUTPUT:=OUTFILE
  COPYSEG(ESSEP,TRUE);
   $(
   LINEIN("");
   IF NEXTIS(EOLTYPE) DO BREAK;
   DEFSTRNUM:=LOPITEM();
   TEST FMEMB(DEFSTRNUM,DEFLIST) NE @NULL THEN
    $(
    OUTPUT:=OOUT;
    OUTSNUM(DEFSTRNUM);
    SPACES(1);
    OUTPUT:=OUTFILE;
    SKIPSEG(ESSEP)
    $)
   OR $( OUTSNUM(DEFSTRNUM); NEWLINE(1); COPYSEG(ESSEP,TRUE) $)
   $) REPEAT;
  NEWLINE(1);
  OUTPUT:=OOUT;
  NEWLINE(1);
  OUTPUT:=OUTFILE
  $);
 COPYTOEND();
 SWAPLITEMS();
 ENDREAD(INPUT);
 INPUT:=OIN;
 ENDWRITE(OUTPUT);
 OUTPUT:=OOUT;
 TEST YESNO("SHALL I REALLY FORGET?:","FORGET-HELP","N") THEN
  $(
  INTERRUPTABLE(FALSE);
  FILEREPLACE(TOPFILENAME(),CGEXT,SC2FILENAME(),CGEXT);
  IF [NEWSS NE @NULL] DO
   $(
   FILEREPLACE(STRFILENAME(),CGEXT,SC1FILENAME(),CGEXT);
   FRPLACA(STRUCSTATUS,CAR(NEWSS));
   MINSTRUCNO:=CAR(CDR(NEWSS));
   MAXSTRUCNO:=CAR(CDR(CDR(NEWSS)));
   IF CAR(NEWSS)=0 DO
    $(
    MAPC(PREVCONS,UNLIST);
    UNLIST(PREVCONS);
    PREVCONS:=@NULL
    UNLESS ALTERNATES=@NULL DO $(
       MAPC(ALTERNATES,UNLIST);
       UNLIST(ALTERNATES)
       ALTERNATES:=@NULL
       $)
    UNLESS ALTS=@NULL DO $(
	UNLIST(ALTS)
	ALTS:=@NULL
	$)

    $);
   UNLIST(NEWSS)
   $);
  WHILE DEFLIST NE @NULL DO
   $(
   DROPPEDENTRY:=ASSOC(CAR(DEFLIST),ALLDEFS);
   DEFLIST:=CDR(DEFLIST);
   ALLDEFS:=DREMOVE(DROPPEDENTRY,ALLDEFS);
   UNLIST(DROPPEDENTRY)
   $);
  INTERRUPTABLE(TRUE);
  RESULTIS TRUE
  $)
 OR
  $(
  DELETEFILE(SC2FILENAME(),CGEXT);
  IF [NEWSS NE @NULL] DO
   $(
   DELETEFILE(SC1FILENAME(),CGEXT);
   UNLIST(NEWSS)
   $);
  RESULTIS FALSE
  $)
 $);




LET LITNUMTRANS(STRNUM) = VALOF
 $( STATIC $( FIRSTCHAR = NIL; INCORRECT = NIL; NUMBER = NIL $);

 LET EACHCHAR(CHAR) BE
  TEST FIRSTCHAR THEN
   $(
   FIRSTCHAR:=FALSE;
   IF CHAR NE '#' DO INCORRECT:=TRUE
   $)
  OR
   TEST [CHAR GE '0'] BITAND [CHAR LE '9'] THEN NUMBER:=NUMBER*10+CHAR-'0'
   OR INCORRECT:=TRUE;

 FIRSTCHAR:=TRUE;
 INCORRECT:=FALSE;
 NUMBER:=0;
 MAPSTR(STROFNUM(STRNUM),EACHCHAR);
 RESULTIS (INCORRECT -> -1,NUMBER)
 $);

LET RANGESUBST(GIVEN,USED,LITNUMFLAG) = VALOF
 $(
 OUTS((LITNUMFLAG -> "I'LL USE #","I'LL USE "));
 OUTNOS(USED);
 OUTS((LITNUMFLAG -> "INSTEAD OF #","INSTEAD OF "));
 OUTNOL(GIVEN);
 RESULTIS USED
 $);

LET FORCEINRANGE(STRUCPOS,LITNUMFLAG) = VALOF
 $( STATIC $( NSTRUCS = NIL; RANGEMIN = NIL; RANGEMAX = NIL $);
 NSTRUCS:=CAR(STRUCSTATUS);
 TEST LITNUMFLAG THEN
  $(
  RANGEMIN:=MINSTRUCNO;
  RANGEMAX:=MAXSTRUCNO;
  $)
 OR $( RANGEMIN:=1; RANGEMAX:=NSTRUCS $);
 IF STRUCPOS<RANGEMIN DO RESULTIS RANGESUBST(STRUCPOS,RANGEMIN,LITNUMFLAG);
 IF STRUCPOS>RANGEMAX DO RESULTIS RANGESUBST(STRUCPOS,RANGEMAX,LITNUMFLAG);
 RESULTIS STRUCPOS 
 $);






LET STRUCSPECREADER(PROMPT,QQSTR,ATOMFLAG) = VALOF
 $( STATIC $( STRUCNUM = NIL; STRUCNAME = NIL; STRUCTYPE = NIL; LOWNUM = NIL;
              HIGHNUM = NIL; TEMP = NIL; POSMINMAXS = NIL;
              LITMINMAXS = NIL; DEFLIST = NIL;
              PARTVAL = NIL
	      SCORES = NIL; LOWSCORE = NIL; HIGHSCORE = NIL; ENTRY = NIL
             $);

 STATIC $( QTBL = [TABLE 12,
     "PLEASE TYPE ONE OR MORE ENTRIES IN ANY OF THE FOLLOWING FORMS:",0,
     "OR: AN INTEGER N, INDICATING THE NTH CASE IN YOUR CURRENT LIST",
     "OR: A PAIR OF INTEGERS IN PARENTHESES, E.G. (1 10); (M N) INDICATES A",
     "    RANGE OF THE MTH THROUGH THE NTH CASES IN YOUR CURRENT LIST",
     "OR: A # FOLLOWED BY AN INTEGER (E.G. #3) INDICATING THE CASE WHICH",
     "    IS 'ATTACHED' TO THE INDEX N (THIS INDEX IS PRINTED IN DRAWINGS)",
     "OR: A PAIR (#M #N) INDICATING A THE RANGE OF CASES ASSOCIATED WITH",
     "    INDICES M THROUGH N",
     "OR: THE WORD 'SCORES' FOLLOWED BY TWO INTEGERS (N,M) TO INDICATE",
     "    THOSE CASES ASSOCIATED WITH SCORES FROM N TO M INCLUSIVE,",
     "    (SCORE VALUES SHOULD BE IN RANGE -99 TO 99 WITH N LESS THAN OR EQUAL TO M)."
     ] $);
 QTBL!2:=(ATOMFLAG -> "    THE NAME OF A DEFINED ATOM OR SUBSTRUCTURE",
                      "    THE NAME OF A DEFINED SUBSTRUCTURE");
 POSMINMAXS:=@NULL;
 LITMINMAXS:=@NULL;
 SCORES:=@NULL;
 DEFLIST:=@NULL;



 TRYPROMPT:
 UNLESS CONDPROMPT(PROMPT,0,QTBL,QQSTR,[TABLE 3,NUMTYPE,STRTYPE,LPARTYPE]) DO
  RESULTIS LIST(POSMINMAXS,LITMINMAXS,SCORES,DREVERSE(DEFLIST));
 SWITCHON LITEMS!LPOSN INTO
  $(
  CASE NUMTYPE:
   IF CAR(STRUCSTATUS)=0 DO GOTO NOSTRUCS;
   STRUCNUM:=FORCEINRANGE(LOPITEM(),FALSE);
   POSMINMAXS:=CONS(CONS(STRUCNUM,STRUCNUM),POSMINMAXS);
   GOTO ANYMORE;
   ENDCASE;
  CASE STRTYPE:
   STRUCNAME:=LITEMS![LPOSN+1];
   STRUCNUM:=LITNUMTRANS(STRUCNAME);
   TEST STRUCNUM>0 THEN
    $(
    IF CAR(STRUCSTATUS)=0 DO GOTO NOSTRUCS;
    LOPITEM();
    STRUCNUM:=FORCEINRANGE(STRUCNUM,TRUE);
    LITMINMAXS:=CONS(CONS(STRUCNUM,STRUCNUM),LITMINMAXS);
    GOTO ANYMORE
    $)
   OR
    $(
    STRUCTYPE:=DEFTYPEOF(STRUCNAME);
    IF STRUCTYPE=0 DO
     $(
     TEST STREQUAL(STROFNUM(STRUCNAME),"SCORES") THEN $(SCRRNG
        IF CAR(STRUCSTATUS)=0 DO GOTO NOSTRUCS;
        LOPITEM();/* Drop the SCORES string. */
        unless NEXTIS(NUMTYPE) do $(
           OUTS("I was expecting an integer giving the minimum score.*C*L")
           FLUSHLINE()
           goto TRYPROMPT
           $)

        LOWSCORE:=LOPITEM()
        unless (-CFMAX<LOWSCORE) & (LOWSCORE<CFMAX) do $(
			OUTS("Score values should be in range ")
			OUTNOS(-CFMAX+1)
			OUTS(" to ");
			OUTNOL(CFMAX-1)
			FLUSHLINE()
			goto TRYPROMPT
			$)

        unless NEXTIS(NUMTYPE) do $(
           OUTS("I was expecting an integer giving the maximum score.*C*L")
           FLUSHLINE()
           goto TRYPROMPT
           $)

        HIGHSCORE:=LOPITEM()
        unless (-CFMAX<HIGHSCORE) & (HIGHSCORE<CFMAX) do $(
			OUTS("Score values should be in range ")
			OUTNOS(-CFMAX+1)
			OUTS(" to ");
			OUTNOL(CFMAX-1)
			FLUSHLINE()
			goto TRYPROMPT
			$)
         
	if LOWSCORE GR HIGHSCORE $( ENTRY:=HIGHSCORE; HIGHSCORE:=LOWSCORE;
			LOWSCORE:=ENTRY;
			OUTS("Reversing score range!*C*L")
			$)
       
  /* Cant store -ve values in lists, so offset these scores */
	LOWSCORE+:=CFMAX; HIGHSCORE+:=CFMAX;

	ENTRY:=CONS(LOWSCORE,HIGHSCORE)
	SCORES:=CONS(ENTRY,SCORES)

	goto ANYMORE

        $)SCRRNG
     OR $(ERR
     OUTSNUM(STRUCNAME);
     OUTS(" ISN'T DEFINED*C*L");
     FLUSHLINE();
     GOTO TRYPROMPT
     $)ERR
     $);
    STRUCTYPE:=STROFNUM(STRUCTYPE);
    UNLESS STREQUAL(STRUCTYPE,"SUBSTRUCTURE") DO
     UNLESS ATOMFLAG BITAND STREQUAL(STRUCTYPE,"ATOM") DO
      $(
      OUTSNUM(STRUCNAME);
      OUTS(" IS DEFINED, BUT NOT AS A SUBSTRUCTURE");
      IF ATOMFLAG DO OUTS(" OR AN ATOM");
      NEWLINE(1);
      FLUSHLINE();
      GOTO TRYPROMPT
      $);
    LOPITEM();
    IF FMEMB(STRUCNAME,DEFLIST)=@NULL DO DEFLIST:=CONS(STRUCNAME,DEFLIST);
    GOTO ANYMORE
    $);
   ENDCASE;
  CASE LPARTYPE:
   IF CAR(STRUCSTATUS)=0 DO GOTO NOSTRUCS;
   LOPITEM();
   SWITCHON LITEMS!LPOSN INTO
    $(
    CASE NUMTYPE:
     LOWNUM:=LITEMS![LPOSN+1];
     IF LOWNUM>CAR(STRUCSTATUS) DO GOTO INCRANGE;
     LOPITEM();
     LOWNUM:=FORCEINRANGE(LOWNUM,FALSE);
     UNLESS NEXTIS(NUMTYPE) DO GOTO INCRANGE;
     HIGHNUM:=LITEMS![LPOSN+1];
     IF HIGHNUM<LOWNUM DO GOTO INCRANGE;
     LOPITEM();
     HIGHNUM:=FORCEINRANGE(HIGHNUM,FALSE);
     IF NEXTIS(RPARTYPE) DO
      $(
      LOPITEM();
      POSMINMAXS:=CONS(CONS(LOWNUM,HIGHNUM),POSMINMAXS);
      GOTO ANYMORE
      $)
     ENDCASE;
    CASE STRTYPE:
     LOWNUM:=LITNUMTRANS(LITEMS![LPOSN+1]);
     IF LOWNUM<0 DO GOTO INCRANGE;
     IF LOWNUM>MAXSTRUCNO DO GOTO INCRANGE;
     LOPITEM();
     LOWNUM:=FORCEINRANGE(LOWNUM,TRUE);
     UNLESS NEXTIS(STRTYPE) DO GOTO INCRANGE;
     HIGHNUM:=LITNUMTRANS(LITEMS![LPOSN+1]);
     IF HIGHNUM<0 DO GOTO INCRANGE;
     IF HIGHNUM<LOWNUM DO GOTO INCRANGE;
     LOPITEM();
     HIGHNUM:=FORCEINRANGE(HIGHNUM,TRUE);
     IF NEXTIS(RPARTYPE) DO
      $(
      LOPITEM();
      LITMINMAXS:=CONS(CONS(LOWNUM,HIGHNUM),LITMINMAXS);
      GOTO ANYMORE
      $)
    $)
  $);
 INCRANGE:
 OUTS("INCORRECT OR INCOMPLETE RANGE - TYPE ? FOR HELP*C*L");
 FLUSHLINE();
 GOTO TRYPROMPT;
 NOSTRUCS:
 OUTS("THERE ARE NO CASES; ONLY SUBSTRUCTURE NAMES");
 IF ATOMFLAG DO OUTS(" OR ATOM NAMES");
 OUTS("*C*LMAKE ANY SENSE AT THIS POINT*C*L");
 FLUSHLINE();
 GOTO TRYPROMPT;
 ANYMORE:
 UNLESS NEXTIS(EOLTYPE) DO GOTO TRYPROMPT;
 RESULTIS LIST(POSMINMAXS,LITMINMAXS,SCORES,DREVERSE(DEFLIST))
 $);

LET CLEANSSLIST(SSLIST) BE
 $(
 MAPC(CAR(SSLIST),UNCONS);
 SSLIST:=UNCONS(SSLIST);
 MAPC(CAR(SSLIST),UNCONS);
 SSLIST:=UNCONS(SSLIST);
 MAPC(CAR(SSLIST),UNCONS); /* SCORERANGE field. */ 
 SSLIST:=UNCONS(SSLIST); 
 UNLIST(CAR(SSLIST));
 UNCONS(SSLIST)
 $);





LET FORGET() BE
 $( STATIC $( SSLIST = NIL; DEFLIST = NIL; TDL = NIL $);
 SSLIST:=STRUCSPECREADER("ITEMS TO BE FORGOTTEN:","FORGET-HELP",TRUE);
 DEFLIST:=CAR(CDR(CDR(CDR(SSLIST))));
 IF FMEMB(HSTRNUM,DEFLIST) NE @NULL DO
  $(
  OUTS("H IS TREATED SPECIALLY IN GENOA AND CAN'T BE FORGOTTEN*C*L");
  DEFLIST:=DREMOVE(HSTRNUM,DEFLIST);
  FRPLACA(CDR(CDR(CDR(SSLIST))),DEFLIST)
  $);
 TDL:=DEFLIST;
 WHILE TDL NE @NULL DO
  TEST CANTCHANGE(CAR(TDL)) THEN
   $(
   DEFLIST:=DREMOVE(CAR(TDL),DEFLIST);
   TDL:=DEFLIST;
   FRPLACA(CDR(CDR(CDR(SSLIST))),DEFLIST)
   $)
  OR TDL:=CDR(TDL);
 UNLESS DROPPER(CAR(CDR(CDR(CDR(SSLIST)))),
		  CAR(SSLIST),
		    CAR(CDR(SSLIST)),
			 CAR(CDR(CDR(SSLIST)))) DO
  OUTS("(NOTHING FORGOTTEN)*C*L");
 CLEANSSLIST(SSLIST)
 $);


GET "ESSHDR.BCL"

LET STRUCPRESENTER(POSMINMAXS,LITMINMAXS,SCORERANGE,PRESENTATION,DFILE) = VALOF
//PRESENTATION IS 1(2) FOR SC1-FILE OUTPUT TO THE DRAW PGM FOR
//NUMBERED(ATNAMED) DRAWINGS; 3 FOR CTABLE OUTPUT TO TTY
 $( STATIC $( NDONE = NIL; OIN = NIL; PRESENT = NIL; NNODES = NIL;
              INODE = NIL; CTE = NIL; DRAWFILE = NIL $);

 LET PRESENT1(STNUM,STRUCPOS,RANGELOC) = VALOF
  $(
  IF (RANGELOC NE 0) DO 
	$( SKIPSEG([127+48] REM 128); RESULTIS RANGELOC<0 $);
  STRCTELIST();


  TEST PRESENT=3 THEN $( 
		NDONE:=NDONE+1;  
		SHOW(STNUM) 
	        $)
  OR NDONE+:=(ESDRAW([PRESENT=1],DRAWFILE,STNUM)->1,0)
  RESULTIS TRUE
  $);

 DRAWFILE:=DFILE;
 NDONE:=0;
 PRESENT:=PRESENTATION;
 OIN:=INPUT;
 INPUT:=FINDFILE("DSK",STRFILENAME(),CGEXT);
 NNODES:=INNO();
 INNO();
 CTELIST:=@NULL;
 INODE:=0;
 WHILE INODE<NNODES DO
  $(
  INODE+:=1;
  CTE:=MAKECTE(INODE);
  FRPLACA(FETCH(CTE.ATS,CTE),NUMOFSTR(INS()));
  CTELIST:=CONS(CTE,CTELIST)
  $);
 ANYBONDS:=@NULL;
 IBLIST:=@NULL;
 MAPSTRUCFILE(POSMINMAXS,LITMINMAXS,SCORERANGE,PRESENT1);
 CLEAR();
 MAPC(IBLIST,UNCONS);
 UNLIST(IBLIST);
 ENDREAD(INPUT);
 INPUT:=OIN;
 RESULTIS NDONE>0
 $);

LET DRAWER(DEFLIST,POSMINMAXS,LITMINMAXS,
		SCORERANGE,PRESENTATION,TERMTYPE) = VALOF
 $( STATIC $( ANYSTRUCS = NIL; OOUT = NIL; OUTFILE = NIL $);
 ANYSTRUCS:=([POSMINMAXS NE @NULL] | [LITMINMAXS NE @NULL] | (SCORERANGE NE @NULL));
 UNLESS ANYSTRUCS BITOR [DEFLIST NE @NULL] DO RESULTIS FALSE;
 OOUT:=OUTPUT;
 OUTFILE:=CREATEFILE("DSK",SC1FILENAME(),CGEXT);
 OUTPUT:=OUTFILE;
 WRITERETTOME(THISPARTSTR);
 OUTNON(TERMTYPE,5);
 NEWLINE(1);
 OUTPUT:=OOUT;
 IF ANYSTRUCS DO
  UNLESS STRUCPRESENTER(POSMINMAXS,LITMINMAXS,
		SCORERANGE,PRESENTATION,OUTFILE) DO
   $(
   OUTS("EMPTY CASE RANGE*C*L");
   IF DEFLIST=@NULL DO
    $(
    ENDWRITE(OUTFILE);
    DELETEFILE(SC1FILENAME(),CGEXT);
    RESULTIS FALSE
    $)
   $);
 STRUCTYPE:=NUMOFSTR("SUBSTRUCTURE");
 WHILE DEFLIST NE @NULL DO
  $(
  STRUCNAME:=CAR(DEFLIST);
  DEFLIST:=CDR(DEFLIST);
  FETCHSUB(STRUCNAME);
  ESDRAW(PRESENTATION=1,OUTFILE,0);
  CLEAR()
  $);
 OUTPUT:=OUTFILE;
 OUTS("-1000*C*L");
 ENDWRITE(OUTPUT);
 OUTPUT:=OOUT;
 RESULTIS TRUE
 $);

LET CGDRAW(TERMTYPE,STEREOCALL) BE
 $( STATIC $( DTYPE = NIL; SSLIST = NIL; FILEPRESENT = NIL $);
 TEST STEREOCALL THEN DTYPE:=2
 OR DTYPE:=PROMPTSELECT("TYPE OF DRAWING:",
                        "NUMBERED ATNAMED FNUMBERED FATNAMED",0,"GENOADRAW-HELP",
                        [TABLE 4,"NUMBERED",1,"ATNAMED",2,"FNUMBERED",3,
                         "FATNAMED",4,0],FALSE);
 IF DTYPE=0 DO RETURN;
 TEST DTYPE>2 THEN DTYPE-:=2 OR FVSINCLUDED:=FALSE;
 SSLIST:=(STEREOCALL ->
           STRUCSPECREADER("ITEMS FOR STEREO ANALYSIS:","STEREO-HELP",FALSE),
           STRUCSPECREADER("ITEMS TO BE DRAWN:","GENOADRAW-HELP",FALSE));
 FILEPRESENT:=DRAWER(CAR(CDR(CDR(CDR(SSLIST)))),
		     CAR(SSLIST),
                     CAR(CDR(SSLIST)),
		     CAR(CDR(CDR(SSLIST))),
		     DTYPE,TERMTYPE);
 FVSINCLUDED:=TRUE;
 CLEANSSLIST(SSLIST);
 UNLESS FILEPRESENT DO RETURN;
 TEST STEREOCALL THEN STARTCGPART1(DNDPPN,"STERCM") OR 
	TEST TERMTYPE < -3 THEN STARTCGPART1(DNDPPN,"GDRAW")
	  OR STARTCGPART1(DNDPPN,"DRAW")
 $);






LET SHOWER(DEFLIST,POSMINMAXS,LITMINMAXS,SCORERANGE) BE
 $( STATIC $( ANYSTRUCS = NIL $);
 ANYSTRUCS:=([POSMINMAXS NE @NULL] | [LITMINMAXS NE @NULL] | (SCORERANGE NE @NULL));
 UNLESS ANYSTRUCS BITOR [DEFLIST NE @NULL] DO RETURN;
 NEWLINE(1);
 IF ANYSTRUCS DO
  UNLESS STRUCPRESENTER(POSMINMAXS,LITMINMAXS,SCORERANGE,3,0) DO
   $(
   OUTS("EMPTY CASE RANGE*C*L");
   IF DEFLIST=@NULL DO RETURN
   $);
 STRUCTYPE:=NUMOFSTR("SUBSTRUCTURE");
 WHILE DEFLIST NE @NULL DO
  $(
  STRUCNAME:=CAR(DEFLIST);
  DEFLIST:=CDR(DEFLIST);
  FETCHSUB(STRUCNAME);
  SHOW(0)
  CLEAR()
  $)
 $);






LET GLIHISTSHOWER() BE
 $( STATIC $( MIN = NIL; MAX = NIL $);
 OPENIN(TOPFILENAME);
 FINDSEG(CHUNKSEP,HIHEADSTR);
 LINEIN("");
 IF NEXTIS(EOLTYPE) DO
  $(
  OUTS("*C*LNO CONSTRAINTS HAVE BEEN GIVEN YET.*C*L*C*L");
  CLOSEIN();
  RETURN
  $);
 OUTS("*C*LTHESE CONSTRAINTS HAVE BEEN APPLIED (MOST RECENT FIRST):*C*L");
 UNTIL NEXTIS(EOLTYPE) DO $(LIST
  STATIC $( ITEM = NIL $)
  ITEM:=LOPITEM();
  OUTSNUM(ITEM);
  TEST (ITEM=NUMOFSTR("ALTERNATIVES")) THEN 
    $(ALTS
	UNTIL NEXTIS(EOLTYPE) DO $( OUTS(" "); 
			OUTSNUM(LOPITEM()); SPACES(1);
			/* Scores in these lists are offset by CFMAX. */
			OUTNOS(LOPITEM()-CFMAX) $) 
	NEWLINE(1)
        LINEIN("")
    $)ALTS
  OR
  TEST (ITEM=NUMOFSTR("ION-COMPOSITION"))  THEN 
    $(IONS
        SPACES(2); OUTSNUM(LOPITEM()); 
	UNTIL NEXTIS(EOLTYPE) DO $( OUTS(" "); 
			OUTSNUM(LOPITEM()); SPACES(1); 
			OUTNOS(LOPITEM()-CFMAX) $) 
	NEWLINE(1)
        LINEIN("")
    $)IONS
  OR
  TEST (ITEM=NUMOFSTR("PRESUPPOSING")) THEN
	$(PRSP
	   UNTIL NEXTIS(EOLTYPE) DO $( SPACES(1); OUTSNUM(LOPITEM()) $)
	   NEWLINE(1)
	$)PRSP
  
  OR test  (ITEM=NUMOFSTR(".SURVEY")) | (ITEM=NUMOFSTR(".ABORTED")) then 
        $(  LINEIN(""); NEWLINE(1) $)
   OR
  $(STND
   OUTS(", ");
   LOPITEM();
   MIN:=LOPITEM();
   MAX:=LOPITEM();
   RANGEOUT(MIN,MAX,TRUE);
   NEWLINE(1);
   LINEIN("")
   $)STND
  $)LIST
 NEWLINE(1);
 CLOSEIN()
 $);




let CHECKABORTED() = valof $(chkabt
 /* If user aborted CASE generation, then don't want him to subsequently
 enter additional constraints or to attmpt generation of structures.
 look for ".ABORTED" on history list.
 (Normally, will be first item on list but not if user went into
 SURVEY and made changes there)
 */
 STATIC $( ITEM = NIL $)
 OPENIN(TOPFILENAME);
 FINDSEG(CHUNKSEP,HIHEADSTR);
 LINEIN("");
 if NEXTIS(EOLTYPE) do $( CLOSEIN(); resultis FALSE $)
 UNTIL NEXTIS(EOLTYPE) DO $(LIST
	 ITEM:=LOPITEM()
	 if (ITEM=NUMOFSTR(".ABORTED")) do  $(bad
		OUTS("*C*LCan not continue processing because previous GLBLD step aborted.");
		CLOSEIN();
		resultis TRUE
		$)bad
	LINEIN("")
	$)LIST

 CLOSEIN();
 resultis FALSE
$)chkabt



LET CGSHOW() BE
 $( STATIC $( STYPE = NIL; SSLIST = NIL; ATDEFS = NIL; SUBDEFS = NIL;
              POSN = NIL; POSN0 = NIL; RMAR = 72 $);

 LET COLLECTAS(NAMEDOTSTUFF) BE
  $( STATIC $( SNAME = NIL $);
  SNAME:=CAR(NAMEDOTSTUFF);
  TEST STREQUAL(STROFNUM(DEFTYPEOF(SNAME)),"ATOM") THEN
   ATDEFS:=CONS(CONS(SNAME,VALENCE(SNAME)),ATDEFS)
  OR SUBDEFS:=CONS(NAMEDOTSTUFF,SUBDEFS)
  $);

 LET PRINAT(ATDOTV) BE
  $( STATIC $( ATSTR = NIL; V = NIL; WIDTH = NIL $);
  ATSTR:=STROFNUM(CAR(ATDOTV));
  V:=CDR(ATDOTV);
  WIDTH:=3+NCHARS(ATSTR)+NCHARSN(V);
  IF POSN+WIDTH>RMAR DO $( NEWLINE(1); SPACES(POSN0); POSN:=POSN0 $);
  SPACES(1);
  OUTS(ATSTR);
  OUTCH('(');
  OUTNO(V);
  OUTCH(')');
  POSN:=POSN+WIDTH
  $);

 LET PRINSUB(STRNUM) BE
  $( STATIC $( STR = NIL; WIDTH = NIL $);
  STR:=STROFNUM(STRNUM);
  WIDTH:=1+NCHARS(STR);
  IF POSN+WIDTH>RMAR DO $( NEWLINE(1); SPACES(POSN0); POSN:=POSN0 $);
  SPACES(1);
  OUTS(STR);
  POSN:=POSN+WIDTH
  $);

 LET PCAR(L) BE PRINSUB(CAR(L));

 STYPE:=PROMPTSELECT("WHAT TO SHOW:","CTABLE STATUS HISTORY LIBRARY SCORES",
                     0,"GENOASHOW-HELP",[TABLE 5,"CTABLE",1,"STATUS",2,"HISTORY",3,
                     "LIBRARY",5, "SCORES",6, 0],FALSE);
 SWITCHON STYPE INTO
  $(
  CASE 1:
   SSLIST:=STRUCSPECREADER("FOR WHICH CASE(S):","GENOADRAW-HELP",FALSE);
   SHOWER(CAR(CDR(CDR(CDR(SSLIST)))),
	   CAR(SSLIST),
	     CAR(CDR(SSLIST)),
	          CAR(CDR(CDR(SSLIST))));
   CLEANSSLIST(SSLIST);
   ENDCASE;
  CASE 2:
   OUTS("YOU CURRENTLY HAVE ");
   TEST CAR(STRUCSTATUS)=0 THEN OUTS("NO CASES*C*L")
   OR
    $(
    OUTNOS(CAR(STRUCSTATUS));
    TEST CAR(STRUCSTATUS)=1 THEN
     $(
     OUTS("CASE, WITH INDEX #");
     OUTNOL(MINSTRUCNO)
     $)
    OR
     $(
     OUTS("CASES, WITH INDICES FROM #");
     OUTNOS(MINSTRUCNO);
     OUTS("TO #");
     OUTNOL(MAXSTRUCNO)
     $);
    ATDEFS:=@NULL;
    SUBDEFS:=@NULL;
    MAPC(CDR(CDR(STRUCSTATUS)),COLLECTAS);
    MAPC(ATDEFS,UNCONS);
    UNLIST(ATDEFS);
    IF SUBDEFS NE @NULL DO
     $(
     OUTS("*C*LSUPERATOMS TO BE IMBEDDED:");
     POSN0:=26;
     POSN:=POSN0;
     MAPC(SUBDEFS,PRINAT);
     UNLIST(SUBDEFS);
     NEWLINE(1)
     $)
    $);
   OUTS("*C*LCURRENT DEFINITIONS:*C*L");
   TEST ALLDEFS=@NULL THEN OUTS("NONE*C*L")
   OR
    $(
    ATDEFS:=@NULL;
    SUBDEFS:=@NULL;
    MAPC(ALLDEFS,COLLECTAS);
    IF ATDEFS NE @NULL DO
     $(
     OUTS("ATOMS(VALENCES IN PARENTHESES):");
     POSN0:=31;
     POSN:=POSN0;
     MAPC(ATDEFS,PRINAT);
     MAPC(ATDEFS,UNCONS);
     UNLIST(ATDEFS);
     NEWLINE(1)
     $);
    IF SUBDEFS NE @NULL DO
     $(
     OUTS("SUBSTRUCTURES:");
     POSN0:=14;
     POSN:=POSN0;
     MAPC(SUBDEFS,PCAR);
     UNLIST(SUBDEFS);
     NEWLINE(1)
     $)
    $);
   OUTS("*C*LMOLECULAR FORMULA IS ");
   TEST MOLFORM=@NULL THEN OUTS("CURRENTLY NOT DEFINED*C*L")
   OR PLIST(MOLFORM,PRINATN,""," "," ","*C*L");
   ENDCASE;
  CASE 3:
   GLIHISTSHOWER();
   ENDCASE;
  CASE 5: SHOWLIB("GENOASHOW-HELP")
	ENDCASE;
  CASE 6: 
    TEST CAR(STRUCSTATUS)=0 THEN OUTS("NO CASES.*C*L") OR SHOWSCORES(); 
    ENDCASE;
  $)
 $);



